﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using HYRN.Common.MyHelper;


namespace HYRN.Common.MyHelper
{
    /// <summary>
    ///  数据类型 转换 
    /// </summary>
    public static class EdgeConvert
    {

        /// <summary>
        /// 双精度装double
        /// </summary>
        /// <param name="b"></param>
        public static double GetDoubleByByte(byte[] byteData)
        {
            // byte[] b = { 0x54, 0x1F, 0x48, 0xDE, 0x39, 0xCA, 0x5A, 0x40 };
            // 105.*******

            double num = BitConverter.ToDouble(byteData, 0);
            return num;
        }


        /// <summary>
        /// CRC16_Modbus效验
        /// </summary>
        /// <param name="byteData">要进行计算的字节数组</param>
        /// <returns>计算后的数组</returns>
        public static byte[] ToModbus(byte[] byteData)
        {
            byte[] CRC = new byte[2];

            UInt16 wCrc = 0xFFFF;
            for (int i = 0; i < byteData.Length; i++)
            {
                wCrc ^= Convert.ToUInt16(byteData[i]);
                for (int j = 0; j < 8; j++)
                {
                    if ((wCrc & 0x0001) == 1)
                    {
                        wCrc >>= 1;
                        wCrc ^= 0xA001;//异或多项式
                    }
                    else
                    {
                        wCrc >>= 1;
                    }
                }
            }

            CRC[1] = (byte)((wCrc & 0xFF00) >> 8);//高位在后
            CRC[0] = (byte)(wCrc & 0x00FF);       //低位在前
            return CRC;

        }




        #region 通用方法

        /// <summary>
        /// int 转 byte[2]
        /// 126  =>   0x00 - 0x7E 
        /// </summary>
        /// <param name="d"></param>
        /// <returns></returns>
        public static byte[] HexStrTo2byte(int d = 126)
        {
            byte[] myByte = new byte[2];  //   =>  126 
            myByte[0] = 0x00;
            myByte[1] = 0x00;
            //===========================

            //十进制转十六进制字符串  
            string str16 = Convert.ToString(d, 16);
            Console.WriteLine(str16);

            byte[] resultStr = HexStrTobyte(str16);

            if (resultStr.Length == 1)
            {
                myByte[1] = resultStr[0];
                return myByte;
            }
            else if (resultStr.Length == 2)
            {

                return resultStr;
            }
            return null;
        }

        /// <summary>
        ///   16进制字符串转 byte[]  
        ///   7E =>  0x00 - 0x7E 
        /// </summary>
        /// <param name="hexString"></param>
        /// <returns></returns>
        private static byte[] HexStrTobyte(string hexString)
        {
            hexString = hexString.Replace(" ", "");
            if ((hexString.Length % 2) != 0)
                hexString += " ";
            byte[] returnBytes = new byte[hexString.Length / 2];
            for (int i = 0; i < returnBytes.Length; i++)
                returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2).Trim(), 16);
            return returnBytes;
        }


        #endregion


        #region MyRegion 计数器 


        /// <summary>
        ///  12.5 => 00-00-42-C8
        /// </summary>
        /// <param name="numA"></param>
        /// <returns></returns>
        public static byte[] GetByte_JiShuQi_DangLiang(float numA)
        {

            byte[] myByteB = new byte[4]; // => 12.5


            byte[] myByteA = BitConverter.GetBytes(numA);


            myByteB[3] = myByteA[2];
            myByteB[2] = myByteA[3];
            myByteB[1] = myByteA[0];
            myByteB[0] = myByteA[1];


            return myByteB;
        }

        /// <summary>
        ///  00-00-42-C8  =>  12.5
        /// </summary>
        /// <param name="myByteA"></param>
        /// <returns></returns>
        public static float GetVal_JiShuQi_DangLiang(byte[] myByteA)
        {

            byte[] myByteB = new byte[4]; // => 12.5
            myByteB[3] = myByteA[2];
            myByteB[2] = myByteA[3];
            myByteB[1] = myByteA[0];
            myByteB[0] = myByteA[1];

            float numC = BitConverter.ToSingle(myByteB, 0);
            return numC;
        }

        /// <summary>
        /// 502913  =>  00-07-AC-81 
        /// </summary>
        /// <param name="myByteA"></param>
        /// <returns></returns>
        public static int GetVal_JiShuQi_ShiJianShuLiang(byte[] myByteA)
        {

            byte[] myByteB = new byte[4]; // => 12.5
            myByteB[3] = myByteA[0];
            myByteB[2] = myByteA[1];
            myByteB[1] = myByteA[2];
            myByteB[0] = myByteA[3];

            var numC = System.BitConverter.ToInt32(myByteB, 0);
            return numC;
        }

        /// <summary>
        /// 00-07-AC-81   =>  502913  
        /// </summary>
        /// <param name="val"></param>
        /// <returns></returns>
        public static byte[] GetByte_JiShuQi_ShiJianShuLiang(int val)
        {
            var myByteC = System.BitConverter.GetBytes(val);


            byte[] myByteB = new byte[4]; // => 12.5
            myByteB[3] = myByteC[0];
            myByteB[2] = myByteC[1];
            myByteB[1] = myByteC[2];
            myByteB[0] = myByteC[3];

            return myByteB;
        }





        #endregion


        /// <summary>
        /// 502913  =>  00-07-AC-81 
        /// </summary>
        /// <param name="myByteA"></param>
        /// <returns></returns>
        public static int GetVal_Cheng_Val(byte[] myByteA)
        {

            byte[] myByteB = new byte[4]; // => 12.5
            myByteB[3] = myByteA[0];
            myByteB[2] = myByteA[1];
            myByteB[1] = myByteA[2];
            myByteB[0] = myByteA[3];

            var numC = System.BitConverter.ToInt32(myByteB, 0);
            return numC;
        }


    }


    //    但是在上位机编程中，采用C#编程就比较麻烦，因为没有union可用
    //但是C#提供一个类system.BitConverter来专门解决这种转换问题,该类如下显示
    //方法
    //DoubleToInt64Bits    将指定的双精度浮点数转换为 64 位有符号整数。
    //GetBytes 已重载。 将指定的数据转换为字节数组。
    //Int64BitsToDouble 将指定的 64 位有符号整数转换成双精度浮点数。
    //ToBoolean 返回由字节数组中指定位置的一个字节转换来的布尔值。
    //ToChar 返回由字节数组中指定位置的两个字节转换来的 Unicode 字符。
    //ToDouble 返回由字节数组中指定位置的八个字节转换来的双精度浮点数。
    //ToInt16 返回由字节数组中指定位置的两个字节转换来的 16 位有符号整数。
    //ToInt32 返回由字节数组中指定位置的四个字节转换来的 32 位有符号整数。
    //ToInt64 返回由字节数组中指定位置的八个字节转换来的 64 位有符号整数。
    //ToSingle 返回由字节数组中指定位置的四个字节转换来的单精度浮点数。
    //ToString 已重载。 将指定的字节数组的每个元素的数值转换为它的等效十六进制字符串表示形式。
    //ToUInt16 返回由字节数组中指定位置的两个字节转换来的 16 位无符号整数。
    //ToUInt32 返回由字节数组中指定位置的四个字节转换来的 32 位无符号整数。
    //ToUInt64 返回由字节数组中指定位置的八个字节转换来的 64 位无符号整数。
    //若想把float类型转化为byte示例如下：
    //float a = 1.23;
    //    byte[] b = BitConverter.GetBytes(a);
    //    若想把变量b重新转化为float类型可以使用toSingle方法，示例如下：
    //float c = BitConverter.ToSingle(b, 0);//应为a在b中其实字节为0，故第二个参数为0

    //    还有就是string与byte[] 的变换 如果知道就很简单
    //     byte[] byteArray = System.Text.Encoding.Default.GetBytes(str);
    //    string str = System.Text.Encoding.Default.GetString(byteArray);
    //    在System.Text.Encoding class中，还有很多其它有用的方法，像GetChars，从一个byte[] 转成一个char[]，等等，还有其它编码方式的，如System.Text.UTF8Encoding class、System.Text.UnicodeEncoding class等，根据不同需要可选不同的class。 具体请参考MSDN





    // 调用
    // var result = ToModbus(temp);
    //             msg[j] = result[0];// 0xFF;
    //             j++;
    //             msg[j] = result[1]; //0xFF;
    //             j++;




}
